---
title: "Swift 语法对比"
description: "通过对比 JavaScript 掌握 Swift 语法，涵盖变量、函数、控制结构和表达式。"
---

## 1. 介绍

### 为什么语法对比很重要

作为从 JavaScript 转向 Swift 的开发者，理解语法差异对于编写清晰、高效的代码至关重要。Swift 的语法设计注重安全性、清晰性和表达性，特别强调类型安全和现代编程实践。

**主要学习目标：**
- 理解 Swift 的类型系统和变量声明
- 掌握函数语法和参数处理
- 学习 Swift 的控制结构和表达式
- 对比 JavaScript 和 Swift 的编码模式
- 培养 Swift 编码最佳实践

## 2. 变量声明和类型

### 2.1 变量声明对比

Swift 使用显式类型注解和类型推断，比 JavaScript 的动态类型提供更好的安全性。

<UniversalEditor title="变量声明对比" compare={true}>
```javascript !! js
// JavaScript 变量声明
let name = "John";           // 字符串
const age = 25;              // 数字
var isStudent = true;        // 布尔值
let scores = [85, 90, 78];   // 数组
let person = {               // 对象
    name: "John",
    age: 25
};

// 运行时类型检查
console.log(typeof name);    // "string"
console.log(typeof age);     // "number"
console.log(typeof isStudent); // "boolean"
```

```swift !! swift
// Swift 变量声明
let name: String = "John"    // 显式类型注解
let age = 25                 // 类型推断 (Int)
let isStudent = true         // 类型推断 (Bool)
let scores = [85, 90, 78]    // 类型推断 ([Int])
let person = [               // 字典字面量
    "name": "John",
    "age": 25
]

// 编译时类型检查
print(type(of: name))        // String
print(type(of: age))         // Int
print(type(of: isStudent))   // Bool
```
</UniversalEditor>

### 2.2 常量 vs 变量

Swift 明确区分常量（`let`）和变量（`var`），类似于 JavaScript 的 `const` 和 `let`。

<UniversalEditor title="常量 vs 变量" compare={true}>
```javascript !! js
// JavaScript 常量和变量
const PI = 3.14159;          // 常量 - 不能重新赋值
let radius = 5;              // 变量 - 可以重新赋值
var diameter = 10;           // 变量（函数作用域）

// 尝试重新赋值常量（会导致错误）
// PI = 3.14; // TypeError: Assignment to constant variable

radius = 7;                  // 有效的重新赋值
console.log(`面积: ${PI * radius * radius}`);
```

```swift !! swift
// Swift 常量和变量
let pi = 3.14159             // 常量 - 不能重新赋值
var radius = 5               // 变量 - 可以重新赋值

// 尝试重新赋值常量（会导致编译错误）
// pi = 3.14 // Error: Cannot assign to value: 'pi' is a 'let' constant

radius = 7                   // 有效的重新赋值
print("面积: \(pi * Double(radius) * Double(radius))")
```
</UniversalEditor>

### 2.3 类型注解

Swift 允许显式类型注解，提高代码清晰度和编译器优化。

<UniversalEditor title="类型注解" compare={true}>
```javascript !! js
// JavaScript - 动态类型
let message = "Hello";       // 字符串
let count = 42;              // 数字
let isActive = true;         // 布尔值

// 类型可以在运行时改变
message = 123;               // 现在是数字
count = "forty-two";         // 现在是字符串
isActive = 1;                // 现在是数字（真值）

console.log(typeof message); // "number"
console.log(typeof count);   // "string"
console.log(typeof isActive); // "number"
```

```swift !! swift
// Swift - 静态类型和类型注解
let message: String = "Hello"    // 显式字符串类型
let count: Int = 42              // 显式整数类型
let isActive: Bool = true        // 显式布尔类型

// 类型不能改变 - 这些会导致编译错误：
// message = 123        // Error: Cannot assign value of type 'Int' to type 'String'
// count = "forty-two"  // Error: Cannot assign value of type 'String' to type 'Int'
// isActive = 1         // Error: Cannot assign value of type 'Int' to type 'Bool'

print(type(of: message))     // String
print(type(of: count))       // Int
print(type(of: isActive))    // Bool
```
</UniversalEditor>

## 3. 函数和方法

### 3.1 函数声明对比

Swift 函数具有更明确的语法，包括参数标签和返回类型。

<UniversalEditor title="函数声明对比" compare={true}>
```javascript !! js
// JavaScript 函数声明
function greet(name) {
    return `Hello, ${name}!`;
}

// 箭头函数
const greetArrow = (name) => {
    return `Hello, ${name}!`;
};

// 多参数函数
function calculateArea(width, height) {
    return width * height;
}

// 默认参数函数
function greetWithDefault(name = "World") {
    return `Hello, ${name}!`;
}

console.log(greet("Alice"));           // "Hello, Alice!"
console.log(calculateArea(10, 5));     // 50
console.log(greetWithDefault());       // "Hello, World!"
```

```swift !! swift
// Swift 函数声明
func greet(name: String) -> String {
    return "Hello, \(name)!"
}

// 多参数函数
func calculateArea(width: Double, height: Double) -> Double {
    return width * height
}

// 默认参数函数
func greetWithDefault(name: String = "World") -> String {
    return "Hello, \(name)!"
}

// 外部参数名函数
func greet(person name: String) -> String {
    return "Hello, \(name)!"
}

print(greet(name: "Alice"))            // "Hello, Alice!"
print(calculateArea(width: 10, height: 5)) // 50.0
print(greetWithDefault())              // "Hello, World!"
print(greet(person: "Bob"))            // "Hello, Bob!"
```
</UniversalEditor>

### 3.2 函数类型和闭包

Swift 将函数视为一等公民，具有显式的函数类型。

<UniversalEditor title="函数类型和闭包" compare={true}>
```javascript !! js
// JavaScript 函数类型和闭包
const add = (a, b) => a + b;
const multiply = (a, b) => a * b;

// 函数作为变量
const operation = add;
console.log(operation(5, 3)); // 8

// 返回函数的函数
const createCalculator = (operation) => {
    return (a, b) => operation(a, b);
};

const calculator = createCalculator(add);
console.log(calculator(10, 5)); // 15

// 高阶函数
const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(x => x * 2);
console.log(doubled); // [2, 4, 6, 8, 10]
```

```swift !! swift
// Swift 函数类型和闭包
let add: (Int, Int) -> Int = { a, b in a + b }
let multiply: (Int, Int) -> Int = { a, b in a * b }

// 函数作为变量
let operation = add
print(operation(5, 3)) // 8

// 返回函数的函数
func createCalculator(operation: @escaping (Int, Int) -> Int) -> (Int, Int) -> Int {
    return operation
}

let calculator = createCalculator(operation: add)
print(calculator(10, 5)) // 15

// 高阶函数
let numbers = [1, 2, 3, 4, 5]
let doubled = numbers.map { $0 * 2 }
print(doubled) // [2, 4, 6, 8, 10]
```
</UniversalEditor>

## 4. 控制结构

### 4.1 条件语句

Swift 的 `if` 语句与 JavaScript 类似，但具有更强的类型检查。

<UniversalEditor title="条件语句" compare={true}>
```javascript !! js
// JavaScript 条件语句
let age = 18;
let hasLicense = true;

if (age >= 18) {
    console.log("你是成年人");
} else if (age >= 13) {
    console.log("你是青少年");
} else {
    console.log("你是儿童");
}

// 真值/假值
let name = "";
let count = 0;
let isActive = false;

if (name) {
    console.log("提供了姓名");
} else {
    console.log("姓名为空");
}

if (count) {
    console.log("计数非零");
} else {
    console.log("计数为零");
}

// 三元运算符
let status = age >= 18 ? "成年人" : "未成年人";
console.log(status);
```

```swift !! swift
// Swift 条件语句
let age = 18
let hasLicense = true

if age >= 18 {
    print("你是成年人")
} else if age >= 13 {
    print("你是青少年")
} else {
    print("你是儿童")
}

// Swift 需要显式的布尔表达式
let name = ""
let count = 0
let isActive = false

if !name.isEmpty {
    print("提供了姓名")
} else {
    print("姓名为空")
}

if count > 0 {
    print("计数非零")
} else {
    print("计数为零")
}

// 三元运算符
let status = age >= 18 ? "成年人" : "未成年人"
print(status)
```
</UniversalEditor>

### 4.2 Switch 语句

Swift 的 `switch` 语句比 JavaScript 更强大，支持模式匹配。

<UniversalEditor title="Switch 语句" compare={true}>
```javascript !! js
// JavaScript switch 语句
let day = "Monday";

switch (day) {
    case "Monday":
        console.log("工作周开始");
        break;
    case "Tuesday":
    case "Wednesday":
    case "Thursday":
        console.log("周中");
        break;
    case "Friday":
        console.log("TGIF!");
        break;
    case "Saturday":
    case "Sunday":
        console.log("周末!");
        break;
    default:
        console.log("无效的日期");
}

// 带 fall-through 的 switch（需要显式 break）
let grade = "B";
switch (grade) {
    case "A":
        console.log("优秀");
        break;
    case "B":
        console.log("良好");
        break;
    case "C":
        console.log("一般");
        break;
    default:
        console.log("需要改进");
}
```

```swift !! swift
// Swift switch 语句和模式匹配
let day = "Monday"

switch day {
case "Monday":
    print("工作周开始")
case "Tuesday", "Wednesday", "Thursday":
    print("周中")
case "Friday":
    print("TGIF!")
case "Saturday", "Sunday":
    print("周末!")
default:
    print("无效的日期")
}

// Swift switch 和范围匹配
let score = 85
switch score {
case 90...100:
    print("A")
case 80..<90:
    print("B")
case 70..<80:
    print("C")
case 60..<70:
    print("D")
case 0..<60:
    print("F")
default:
    print("无效分数")
}

// Swift switch 和元组匹配
let point = (2, 0)
switch point {
case (0, 0):
    print("原点")
case (_, 0):
    print("在 x 轴上")
case (0, _):
    print("在 y 轴上")
case (-2...2, -2...2):
    print("接近原点")
default:
    print("其他地方")
}
```
</UniversalEditor>

### 4.3 循环

Swift 提供多种循环结构，适用于不同场景。

<UniversalEditor title="循环对比" compare={true}>
```javascript !! js
// JavaScript 循环
const numbers = [1, 2, 3, 4, 5];

// For 循环
for (let i = 0; i < numbers.length; i++) {
    console.log(numbers[i]);
}

// For...of 循环（遍历值）
for (const num of numbers) {
    console.log(num);
}

// For...in 循环（遍历键）
const person = { name: "John", age: 30 };
for (const key in person) {
    console.log(`${key}: ${person[key]}`);
}

// While 循环
let count = 0;
while (count < 5) {
    console.log(count);
    count++;
}

// Do...while 循环
let i = 0;
do {
    console.log(i);
    i++;
} while (i < 3);

// 数组方法
numbers.forEach(num => console.log(num));
const doubled = numbers.map(num => num * 2);
const evens = numbers.filter(num => num % 2 === 0);
```

```swift !! swift
// Swift 循环
let numbers = [1, 2, 3, 4, 5]

// For-in 循环（遍历值）
for num in numbers {
    print(num)
}

// For-in 循环和范围
for i in 0..<numbers.count {
    print(numbers[i])
}

// For-in 循环和 stride
for i in stride(from: 0, to: 10, by: 2) {
    print(i) // 0, 2, 4, 6, 8
}

// While 循环
var count = 0
while count < 5 {
    print(count)
    count += 1
}

// Repeat-while 循环（相当于 do-while）
var i = 0
repeat {
    print(i)
    i += 1
} while i < 3

// 字典迭代
let person = ["name": "John", "age": "30"]
for (key, value) in person {
    print("\(key): \(value)")
}

// 数组方法
numbers.forEach { print($0) }
let doubled = numbers.map { $0 * 2 }
let evens = numbers.filter { $0 % 2 == 0 }
```
</UniversalEditor>

## 5. 运算符和表达式

### 5.1 基本运算符

Swift 运算符与 JavaScript 类似，但具有更强的类型安全性。

<UniversalEditor title="基本运算符" compare={true}>
```javascript !! js
// JavaScript 运算符
let a = 10;
let b = 3;

// 算术运算符
console.log(a + b);  // 13
console.log(a - b);  // 7
console.log(a * b);  // 30
console.log(a / b);  // 3.333...
console.log(a % b);  // 1
console.log(a ** b); // 1000

// 赋值运算符
let x = 5;
x += 3;  // x = x + 3
x -= 2;  // x = x - 2
x *= 4;  // x = x * 4
x /= 2;  // x = x / 2

// 比较运算符
console.log(a == b);   // false
console.log(a != b);   // true
console.log(a > b);    // true
console.log(a >= b);   // true

// 逻辑运算符
let isTrue = true;
let isFalse = false;
console.log(isTrue && isFalse);  // false
console.log(isTrue || isFalse);  // true
console.log(!isTrue);            // false
```

```swift !! swift
// Swift 运算符
let a = 10
let b = 3

// 算术运算符
print(a + b)  // 13
print(a - b)  // 7
print(a * b)  // 30
print(a / b)  // 3 (整数除法)
print(a % b)  // 1
print(pow(Double(a), Double(b))) // 1000.0

// 赋值运算符
var x = 5
x += 3  // x = x + 3
x -= 2  // x = x - 2
x *= 4  // x = x * 4
x /= 2  // x = x / 2

// 比较运算符
print(a == b)   // false
print(a != b)   // true
print(a > b)    // true
print(a >= b)   // true

// 逻辑运算符
let isTrue = true
let isFalse = false
print(isTrue && isFalse)  // false
print(isTrue || isFalse)  // true
print(!isTrue)            // false

// 范围运算符
let range1 = 1...5    // 闭区间 (1, 2, 3, 4, 5)
let range2 = 1..<5    // 半开区间 (1, 2, 3, 4)
```
</UniversalEditor>

### 5.2 字符串操作

Swift 提供强大的字符串插值和操作功能。

<UniversalEditor title="字符串操作" compare={true}>
```javascript !! js
// JavaScript 字符串操作
let firstName = "John";
let lastName = "Doe";

// 字符串连接
let fullName = firstName + " " + lastName;
console.log(fullName); // "John Doe"

// 模板字面量
let greeting = `Hello, ${firstName} ${lastName}!`;
console.log(greeting); // "Hello, John Doe!"

// 字符串方法
let message = "Hello World";
console.log(message.length);           // 11
console.log(message.toUpperCase());    // "HELLO WORLD"
console.log(message.toLowerCase());    // "hello world"
console.log(message.indexOf("World")); // 6
console.log(message.substring(0, 5));  // "Hello"
console.log(message.replace("World", "Swift")); // "Hello Swift"

// 字符串比较
let str1 = "apple";
let str2 = "Apple";
console.log(str1 === str2); // false
console.log(str1.toLowerCase() === str2.toLowerCase()); // true
```

```swift !! swift
// Swift 字符串操作
let firstName = "John"
let lastName = "Doe"

// 字符串连接
let fullName = firstName + " " + lastName
print(fullName) // "John Doe"

// 字符串插值
let greeting = "Hello, \(firstName) \(lastName)!"
print(greeting) // "Hello, John Doe!"

// 字符串方法
let message = "Hello World"
print(message.count)                    // 11
print(message.uppercased())             // "HELLO WORLD"
print(message.lowercased())             // "hello world"
print(message.contains("World"))        // true
print(message.prefix(5))                // "Hello"
print(message.replacingOccurrences(of: "World", with: "Swift")) // "Hello Swift"

// 字符串比较
let str1 = "apple"
let str2 = "Apple"
print(str1 == str2) // false
print(str1.lowercased() == str2.lowercased()) // true

// 多行字符串
let multiLine = """
    This is a
    multi-line
    string in Swift
    """
print(multiLine)
```
</UniversalEditor>

## 6. 注释和文档

### 6.1 注释样式

两种语言都支持类似的注释样式，但 Swift 有额外的文档功能。

<UniversalEditor title="注释和文档" compare={true}>
```javascript !! js
// JavaScript 注释和文档

// 单行注释
let name = "John"; // 这是一个变量

/*
 * 多行注释
 * 这是一个块注释
 * 可以跨越多行
 */

/**
 * JSDoc 函数文档注释
 * @param {string} name - 要问候的名字
 * @param {number} age - 人的年龄
 * @returns {string} 问候消息
 */
function greetPerson(name, age) {
    return `Hello ${name}, you are ${age} years old`;
}

// 内联注释
let result = 5 + 3; // 计算总和
```

```swift !! swift
// Swift 注释和文档

// 单行注释
let name = "John" // 这是一个变量

/*
 * 多行注释
 * 这是一个块注释
 * 可以跨越多行
 */

/**
 * Swift 文档注释
 * - Parameter name: 要问候的名字
 * - Parameter age: 人的年龄
 * - Returns: 问候消息
 */
func greetPerson(name: String, age: Int) -> String {
    return "Hello \(name), you are \(age) years old"
}

// 内联注释
let result = 5 + 3 // 计算总和

// MARK: - 代码组织部分标记
// MARK: 属性
let title = "My App"

// MARK: 方法
func doSomething() {
    // 实现
}

// TODO: - 未来工作提醒
// TODO: 实现错误处理

// FIXME: - 标记需要修复的 bug
// FIXME: 这个需要优化
```
</UniversalEditor>

## 7. 练习

### 练习 1: 变量和函数练习

<UniversalEditor title="练习 1: 基础语法" compare={true}>
```javascript !! js
// JavaScript 练习
// 1. 声明一个人的信息变量
let personName = "Alice";
let personAge = 25;
let personCity = "New York";

// 2. 创建计算 BMI 的函数
function calculateBMI(weight, height) {
    return weight / (height * height);
}

// 3. 创建返回格式化字符串的函数
function formatPersonInfo(name, age, city) {
    return `${name} is ${age} years old and lives in ${city}`;
}

// 4. 测试函数
let bmi = calculateBMI(70, 1.75);
console.log(`BMI: ${bmi.toFixed(2)}`);
console.log(formatPersonInfo(personName, personAge, personCity));
```

```swift !! swift
// Swift 练习
// 1. 声明一个人的信息变量
let personName: String = "Alice"
let personAge: Int = 25
let personCity: String = "New York"

// 2. 创建计算 BMI 的函数
func calculateBMI(weight: Double, height: Double) -> Double {
    return weight / (height * height)
}

// 3. 创建返回格式化字符串的函数
func formatPersonInfo(name: String, age: Int, city: String) -> String {
    return "\(name) is \(age) years old and lives in \(city)"
}

// 4. 测试函数
let bmi = calculateBMI(weight: 70, height: 1.75)
print("BMI: \(String(format: "%.2f", bmi))")
print(formatPersonInfo(name: personName, age: personAge, city: personCity))
```
</UniversalEditor>

### 练习 2: 控制流练习

<UniversalEditor title="练习 2: 控制流" compare={true}>
```javascript !! js
// JavaScript 控制流练习
function gradeCalculator(score) {
    if (score >= 90) {
        return "A";
    } else if (score >= 80) {
        return "B";
    } else if (score >= 70) {
        return "C";
    } else if (score >= 60) {
        return "D";
    } else {
        return "F";
    }
}

function numberAnalyzer(number) {
    let result = "";
    
    if (number > 0) {
        result += "正数 ";
    } else if (number < 0) {
        result += "负数 ";
    } else {
        result += "零 ";
    }
    
    if (number % 2 === 0) {
        result += "偶数";
    } else {
        result += "奇数";
    }
    
    return result;
}

// 测试函数
console.log(gradeCalculator(85)); // "B"
console.log(numberAnalyzer(7));   // "正数 奇数"
console.log(numberAnalyzer(-4));  // "负数 偶数"
```

```swift !! swift
// Swift 控制流练习
func gradeCalculator(score: Int) -> String {
    switch score {
    case 90...100:
        return "A"
    case 80..<90:
        return "B"
    case 70..<80:
        return "C"
    case 60..<70:
        return "D"
    case 0..<60:
        return "F"
    default:
        return "无效分数"
    }
}

func numberAnalyzer(number: Int) -> String {
    var result = ""
    
    if number > 0 {
        result += "正数 "
    } else if number < 0 {
        result += "负数 "
    } else {
        result += "零 "
    }
    
    if number % 2 == 0 {
        result += "偶数"
    } else {
        result += "奇数"
    }
    
    return result
}

// 测试函数
print(gradeCalculator(score: 85)) // "B"
print(numberAnalyzer(number: 7))   // "正数 奇数"
print(numberAnalyzer(number: -4))  // "负数 偶数"
```
</UniversalEditor>

## 8. 关键要点

### 8.1 语法差异总结

| 特性 | JavaScript | Swift | 关键差异 |
|---|---|---|---|
| **变量声明** | `let/const/var` | `let/var` | Swift 使用 `let` 表示常量，没有 `const` |
| **类型系统** | 动态类型 | 静态类型 | Swift 需要显式类型或类型推断 |
| **函数参数** | 无标签 | 外部参数名 | Swift 使用参数标签提高清晰度 |
| **字符串插值** | `${variable}` | `\(variable)` | 字符串插值的不同语法 |
| **Switch 语句** | 基本匹配 | 模式匹配 | Swift 支持复杂的模式匹配 |
| **循环语法** | `for...of`, `for...in` | `for...in` | Swift 的 `for...in` 更通用 |
| **类型检查** | 运行时 | 编译时 | Swift 在执行前捕获错误 |

### 8.2 最佳实践

1. **使用类型注解**: 显式声明类型提高代码清晰度
2. **优先使用常量**: 尽可能使用 `let` 而不是 `var`
3. **使用参数标签**: 使函数调用更易读
4. **利用模式匹配**: 使用 Swift 强大的 switch 语句
5. **编写清晰文档**: 使用 Swift 的文档注释
6. **遵循命名约定**: 变量和函数使用 camelCase
7. **使用字符串插值**: 优先使用 `\(variable)` 而不是连接

### 8.3 常见陷阱

1. **忘记类型注解**: Swift 的类型推断很好，但显式类型有帮助
2. **混用 `let` 和 `var`**: 常量使用 `let`，只在需要时使用 `var`
3. **忽略参数标签**: 它们使代码更易读
4. **不使用模式匹配**: Swift 的 switch 语句很强大
5. **String vs Character**: Swift 区分 String 和 Character 类型

## 9. 下一步

在下一个模块中，我们将详细探索 Swift 的类型系统，包括：
- 可选类型和 nil 安全性
- 类型推断和类型注解
- 类型别名和类型转换
- 类型安全编程实践

这个 Swift 语法基础将为你准备即将到来的模块中的更高级概念。 